

#include <stdio.h>


//#include <assert.h>
//#include <stdlib.h>
//struct ListNode 
//{
//    int val;
//    struct ListNode* next;
//};
//
//typedef struct ListNode LTNode;
//
//struct ListNode* _reverse(struct ListNode* beg, struct ListNode* end)
//{
//    struct ListNode* newhead = NULL;
//    struct ListNode* cur = beg, * aft = end->next;
//    while (cur != aft)
//    {
//        struct ListNode* pnext = cur->next;
//
//        if (!newhead)
//        {
//            newhead = cur;
//            cur->next = NULL;
//        }
//        else
//        {
//            cur->next = newhead;
//            newhead = cur;
//        }
//
//        cur = pnext;
//    }
//
//    return newhead;
//}
//
//struct ListNode* reverseBetween1(struct ListNode* head, int m, int n)
//{
//    if (m == n)
//        return head;
//
//    struct ListNode* cur = head;
//    struct ListNode* prev = head, * aft = head;
//    struct ListNode* beg = NULL, * end = NULL;
//    int cnt = 1;
//    while (cur)
//    {
//        if (m - 1 == cnt)
//            prev = cur;
//
//        if (m == cnt)
//            beg = cur;
//
//        if (n == cnt)
//        {
//            end = cur;
//            aft = cur->next;
//            break;
//        }
//
//        cur = cur->next;
//        ++cnt;
//    }
//
//    struct ListNode* newhead = _reverse(beg, end);
//    if (1 == m)
//        ;
//    else
//        prev->next = newhead;
//
//    beg->next = aft;
//
//    if (1 == m)
//        return newhead;
//    else
//        return head;
//}
//
//typedef struct ListNode LTNode;
//struct ListNode* reverseBetween2(struct ListNode* head, int m, int n)
//{
//    LTNode* flag = (LTNode*)malloc(sizeof(LTNode));
//    assert(flag);
//    flag->next = head, flag->val = -1;
//
//    LTNode* cur = flag, * prev = NULL;
//    for (int i = 1; i < m; ++i)
//    {
//        cur = cur->next;
//    }
//    prev = cur;
//
//    cur = head;
//    for (int i = 1; i < m; ++i)
//    {
//        cur = cur->next;
//    }
//
//    LTNode* pnext = NULL;
//    for (int i = 0; i < n - m; ++i)
//    {
//        pnext = cur->next;
//
//        cur->next = pnext->next;
//        pnext->next = prev->next;
//        prev->next = pnext;
//    }
//
//    LTNode* ret = flag->next;
//    free(flag);
//
//    return ret;
//}
//
//LTNode* BuyNode(int x)
//{
//    LTNode* node = (LTNode*)malloc(sizeof(LTNode));
//    assert(node);
//
//    node->val = x;
//    node->next = NULL;
//
//    return node;
//}
//
//struct ListNode* CreateList(void)
//{
//    LTNode* n1 = BuyNode(1);
//    LTNode* n2 = BuyNode(2);
//    LTNode* n3 = BuyNode(3);
//    LTNode* n4 = BuyNode(4);
//    LTNode* n5 = BuyNode(5);
//    n1->next = n2;
//    n2->next = n3;
//    n3->next = n4;
//    n4->next = n5;
//    
//    return n1;
//}
//
//void PrintList(LTNode* head)
//{
//    assert(head);
//
//    LTNode* cur = head;
//    while (cur)
//    {
//        printf("%d->", cur->val);
//        cur = cur->next;
//    }
//    printf("NULL\n");
//}
//
//int main()
//{
//    int m = 2, n = 4;
//    LTNode* head = CreateList();
//
//    PrintList(head);
//    reverseBetween1(head, m, n);
//    PrintList(head);
//    putchar('\n');
//
//    head = CreateList();
//    PrintList(head);
//    reverseBetween2(head, m, n);
//    PrintList(head);
//
//	return 0;
//}

#include <assert.h>
#include <stdlib.h>
struct ListNode 
{
    int val;
    struct ListNode* next;
};

typedef struct ListNode BTNode;
struct ListNode* removeZeroSumSublists(struct ListNode* head)
{
    BTNode* phead = (BTNode*)malloc(sizeof(BTNode));
    assert(phead);
    phead->next = head, phead->val = 0;

    BTNode* cur = head, * curr = NULL; 
    BTNode* pnext = NULL, * prev = phead;
    int sum = 0, flag = 0;
    while (cur)
    {
        sum = 0, flag = 0;
        pnext = cur->next;

        curr = cur;
        while (curr)
        {
            sum += curr->val;

            if (0 == sum)
            {
                sum = 0,flag = 1;
                prev->next = curr->next;
                pnext = curr->next;
                curr = pnext;
            }
            else
            {
                curr = curr->next;
            }
        }
        
        if (flag)
            ;
        else
            prev = cur;

        cur = pnext;
    }

    BTNode* ret = phead->next;
    free(phead);

    return ret;
}

BTNode* BuyNode(int x)
{
    BTNode* node = (BTNode*)malloc(sizeof(BTNode));
    assert(node);

    node->val = x;
    node->next = NULL;

    return node;
}

struct ListNode* CreateList(void)
{
    BTNode* n1 = BuyNode(1);
    BTNode* n2 = BuyNode(2);
    BTNode* n3 = BuyNode(-3);
    BTNode* n4 = BuyNode(3);
    BTNode* n5 = BuyNode(1);
    n1->next = n2;
    n2->next = n3;
    n3->next = n4;
    n4->next = n5;
    
    return n1;
}

void PrintList(BTNode* head)
{
    assert(head);

    BTNode* cur = head;
    while (cur)
    {
        printf("%d ", cur->val);
        cur = cur->next;
    }
    printf("NULL\n");
}

int main()
{
    BTNode* head = CreateList();

    PrintList(head);
    PrintList(removeZeroSumSublists(head));

    return 0;
}